FEXPDataContainer.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Data management model
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPDATACONTAINER_H_
#define _CFEXPDATACONTAINER_H_
#include "FEXPCommon.h"
#include "FEXPSerialization.h"
#include "FEXPGeom.h"

// typedef for FE model data
using t_ModelDataKey = std::string;
using t_ModelDataDta = std::vector<std::string>;
using t_ModelData    = std::map<t_ModelDataKey, Ptr<t_ModelDataDta>>;


enum ESystemElementType { eSetting, eMaterial, eNode, eElement, eConstrain, eLoad, eResult, eElementCount };
class ICFEXPModelDataIntf
  : public ICFEXPSerialize
{
public:
  virtual size_t GetId          ()          = 0;
  virtual size_t GetModelId     ()          = 0;
  virtual size_t GetType        ()          = 0;
  virtual size_t GetThreadId    ()          = 0;
  virtual size_t GetThreadNumber()          = 0;
  virtual void   SetThreadId    (size_t id) = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class CFEXPModelDataWrapper
  : public ICFEXPDataWrapperBase<ICFEXPModelDataIntf, size_t>
{
public:
  CFEXPModelDataWrapper(Ptr<ICFEXPModelDataIntf> & element);
  CFEXPModelDataWrapper(const CFEXPModelDataWrapper & source);
  virtual ~CFEXPModelDataWrapper() { }

  // override interface forces virtual functions
  virtual size_t GetKey() override { return GetData()->GetId(); }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPDataModelContIntf
{
public:
  virtual ~ICFEXPDataModelContIntf() { }
  // pure virtual member functions for adding and getting elements
  virtual void AddModelElement(Ptr<ICFEXPModelDataIntf> & el, size_t opt_id)                   = 0;
  virtual Ptr<ICFEXPModelDataIntf> GetModelElement(size_t id, size_t opt_id)                   = 0;
  virtual Ptr<ICFEXPModelDataIntf> GetModelElement(size_t id, size_t opt_id, size_t thread_id) = 0;
  using t_IterFunc = std::function<bool(Ptr<ICFEXPModelDataIntf>)>;
  virtual void IterateModElems(t_IterFunc function, size_t opt_id)                   = 0;
  virtual void IterateModElems(t_IterFunc function, size_t opt_id, size_t thread_id) = 0;
  // key checker
  virtual bool ContainsKey(size_t id, size_t opt_id)                          = 0;
  virtual bool RemoveItem (size_t id, size_t opt_id)                          = 0;
  virtual bool RemoveItem (const std::map<size_t, std::vector<size_t>> & ids) = 0;
  virtual bool RemoveAll  (size_t opt_id)                                     = 0;
  
  // thread scheduling
  virtual void ScheduleThreads(size_t opt_id) = 0;
  // check if container is empty
  virtual size_t ItemCount(size_t opt_id) = 0;
  virtual bool   IsEmpty  (size_t opt_id) = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class CFEXPModelContainerBase
  : public ICFEXPDataModelContIntf, public ICFEXPDataContainerBase<CFEXPModelDataWrapper, ICFEXPModelDataIntf, size_t>
{
public:
  CFEXPModelContainerBase();
  virtual ~CFEXPModelContainerBase() { }
  // override interface virtual functions of fe cont. base
  virtual void AddModelElement(Ptr<ICFEXPModelDataIntf> & el, size_t opt_id)                   override;
  virtual Ptr<ICFEXPModelDataIntf> GetModelElement(size_t id, size_t opt_id)                   override;
  virtual Ptr<ICFEXPModelDataIntf> GetModelElement(size_t id, size_t opt_id, size_t thread_id) override;
  virtual void IterateModElems(t_IterFunc function, size_t opt_id)                   override;
  virtual void IterateModElems(t_IterFunc function, size_t opt_id, size_t thread_id) override;

  virtual bool   ContainsKey    (size_t id, size_t opt_id)                          override { return Contains(id); }
  virtual bool   RemoveItem     (size_t id, size_t opt_id)                          override;
  virtual bool   RemoveItem     (const std::map<size_t, std::vector<size_t>> & ids) override;
  virtual bool   RemoveAll      (size_t opt_id)                                     override;
  virtual void   ScheduleThreads(size_t opt_id)                                     override;
  virtual size_t ItemCount      (size_t opt_id)                                     override;
  virtual bool   IsEmpty        (size_t opt_id)                                     override;
protected:
  std::map<size_t, std::map<size_t, size_t>> _thread_mapper;
  void add_new_thread_item(size_t thread, size_t id);
private:
  // [no private members  ] -----------------------------
};

#define SETTING_CONTAINER_NAME "SETTING_CONTAINER"

class CFEXPSettingContainer
  : public CFEXPModelContainerBase
{
public:
  CFEXPSettingContainer();
  virtual ~CFEXPSettingContainer() { }

  // override interface virtual functions of container bases
  virtual std::string GetContainerName() const override { return SETTING_CONTAINER_NAME; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// container class name simplification
using t_STTContainer = CFEXPSettingContainer;

#define MATERIAL_CONTAINER_NAME "MATERIAL_CONTAINER"

class CFEXPMaterialContainer
  : public CFEXPModelContainerBase
{
public:
  CFEXPMaterialContainer();
  virtual ~CFEXPMaterialContainer() { }

  // override interface virtual functions of container bases
  virtual std::string GetContainerName() const override { return MATERIAL_CONTAINER_NAME; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// container class name simplification
using t_MATContainer = CFEXPMaterialContainer;

#define FINITE_ELEMENT_CONTAINER_NAME "FE_CONTAINER"

class CFEXPFiniteElementContainer
  : public CFEXPModelContainerBase
{
public:
  CFEXPFiniteElementContainer();
  virtual ~CFEXPFiniteElementContainer() { }

  // override interface virtual functions of container bases
  virtual std::string GetContainerName() const override { return FINITE_ELEMENT_CONTAINER_NAME; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// container class name simplification
using t_FEContainer = CFEXPFiniteElementContainer;

#define FINITE_ELEMENT_NODE_CONTAINER_NAME "FE_NODE_CONTAINER"

class CFEXPFiniteElementNodeContainer
  : public CFEXPModelContainerBase
{
public:
  CFEXPFiniteElementNodeContainer();
  virtual ~CFEXPFiniteElementNodeContainer() { }

  // override interface virtual functions of container bases
  virtual std::string GetContainerName() const override { return FINITE_ELEMENT_NODE_CONTAINER_NAME; }
protected:
  // [no protected members] -----------------------------
private:
  std::map<size_t, std::vector<size_t>> _thread_mapper;
};

// container class name simplification
using t_FENContainer = CFEXPFiniteElementNodeContainer;

#define FINITE_ELEMENT_NODE_CONSTRAIN_CONTAINER_NAME "FE_NODE_CONSTRAIN_CONTAINER"

class CFEXPFiniteElementNodeConstrainContainer
  : public CFEXPModelContainerBase
{
public:
  CFEXPFiniteElementNodeConstrainContainer();
  virtual ~CFEXPFiniteElementNodeConstrainContainer() { }

  // override interface virtual functions of container bases
  virtual std::string GetContainerName() const override { return FINITE_ELEMENT_NODE_CONSTRAIN_CONTAINER_NAME; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// container class name simplification
using t_FENCContainer = CFEXPFiniteElementNodeConstrainContainer;

#define FINITE_ELEMENT_NODE_LOAD_CONTAINER_NAME "FE_NODE_LOAD_CONTAINER"

class CFEXPFiniteElementNodeLoadContainer
  : public CFEXPModelContainerBase
{
public:
  CFEXPFiniteElementNodeLoadContainer();
  virtual ~CFEXPFiniteElementNodeLoadContainer() { }

  // override interface virtual functions of container bases
  virtual std::string GetContainerName() const override { return FINITE_ELEMENT_NODE_LOAD_CONTAINER_NAME; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// container class name simplification
using t_FENLContainer = CFEXPFiniteElementNodeLoadContainer;

#define FINITE_ELEMENT_RESULT_CONTAINER_NAME "FE_RESULT_CONTAINER"

class CFEXPFiniteElementResultContainer
  : public CFEXPModelContainerBase
{
public:
  CFEXPFiniteElementResultContainer();
  virtual ~CFEXPFiniteElementResultContainer() { }

  // override interface virtual functions of container bases
  virtual std::string GetContainerName() const override { return FINITE_ELEMENT_RESULT_CONTAINER_NAME; }
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};

// container class name simplification
using t_FERSTLContainer = CFEXPFiniteElementResultContainer;


class CFEXPMainDataContainer
  : public ICFEXPDataModelContIntf
{
public:
  CFEXPMainDataContainer();
  virtual ~CFEXPMainDataContainer() { }

  // override interface virtual functions of container bases
  virtual void AddModelElement(Ptr<ICFEXPModelDataIntf> & el, size_t opt_id)                   override;
  virtual Ptr<ICFEXPModelDataIntf> GetModelElement(size_t id, size_t opt_id)                   override;
  virtual Ptr<ICFEXPModelDataIntf> GetModelElement(size_t id, size_t opt_id, size_t thread_id) override;
  virtual void IterateModElems(t_IterFunc function, size_t opt_id)                   override;
  virtual void IterateModElems(t_IterFunc function, size_t opt_id, size_t thread_id) override;

  virtual bool   ContainsKey    (size_t id, size_t opt_id)                          override;
  virtual bool   RemoveItem     (size_t id, size_t opt_id)                          override;
  virtual bool   RemoveItem     (const std::map<size_t, std::vector<size_t>> & ids) override;
  virtual bool   RemoveAll      (size_t opt_id)                                     override;
  virtual void   ScheduleThreads(size_t opt_id)                                     override;
  virtual size_t ItemCount      (size_t opt_id)                                     override;
  virtual bool   IsEmpty        (size_t opt_id)                                     override;
protected:
  Ptr<ICFEXPDataModelContIntf> get_container(size_t opt_id);
private:
  std::map<ESystemElementType, Ptr<ICFEXPDataModelContIntf>> _model_container;
};

#endif // !_CFEXPDATACONTAINER_H_